import type { BaseResponse } from '../models/up_response.ts';
import type { AxiosError } from 'axios';
import { log } from '../ipc/log';
import {isPortNotExist, isPortOccupied} from "./command";

// export function errorMessage(error: unknown) {
//     function handleResponseError() {
//         const response = error.response;
//         const data: BaseResponse = response.data;
//
//         // 组合错误日志信息
//         const errorCode = data.code !== undefined ? `Code: ${data.code}` : '';
//         const errorMessage = data.message ? `Message: ${data.message}` : 'No message provided';
//
//         const errorData = data.data ? `Data: ${JSON.stringify(data.data, null, 2)}` : ''; // 格式化 JSON 输出
//         return `${errorCode} - ${errorMessage}${errorData ? `\n${errorData}` : ''}`;
//     }
//
//     function handleNoResponseError() {
//         return '服务器无响应:';
//     }
//
//     let message = '';
//     if (error.response) {
//         message = handleResponseError();
//     } else if (error.request) {
//         message = handleNoResponseError();
//     } else {
//         message = `错误: ${(error as any).message}`;
//     }
//
//     ElMessage.error(message);
// }

export function getSerialErrorMessage(error: unknown): { isSerialError: boolean, errorMessage: string } {
  function parseSerialErrorMessage(error: AxiosError){
    const response = error.response!;
    const status = response.status;

    if (status == 400) {
      const data: BaseResponse<any> = response.data as BaseResponse<any>;

      const errorMessage = data.message
          ? `Message: ${data.message}`
          : 'No message provided';

      if (isPortNotExist(errorMessage)) {
        return "串口不存在，请检查设备连接是否正确或串口号是否正确";
      } else if (isPortOccupied(errorMessage)) {
        return "串口被占用，请关闭其他可能占用串口的软件或重启设备";
      }
    }

    return undefined;
  }

  if (isAxiosError(error)) {
    if (error.response) {
      const message = parseSerialErrorMessage(error)
      if (message) {
        return { isSerialError: true, errorMessage: message };
      }
    }
  }

  return { isSerialError: false, errorMessage: '未知错误' };
}

export function handleUpError(error: unknown) {
  function handleResponseError(error: AxiosError) {
    const response = error.response;

    if (response) {
      const status = response.status;
      const data: BaseResponse<any> = response.data as BaseResponse<any>;

      // 组合错误日志信息
      const errorCode = data.code !== undefined ? `Code: ${data.code}` : '';
      const errorMessage = data.message
        ? `Message: ${data.message}`
        : 'No message provided';

      const errorData = data.data
        ? `Data: ${JSON.stringify(data.data, null, 2)}`
        : ''; // 格式化 JSON 输出
      const logMessage = `${errorCode} - ${errorMessage}${errorData ? `\n${errorData}` : ''}`;

      switch (status) {
        case 400:
          log.error(`请求错误: ${logMessage}`);
          break;
        case 403:
          log.error(`权限错误: ${logMessage}`);
          break;
        case 404:
          log.error(`资源未找到: ${logMessage}`);
          break;
        case 408:
          log.error(`请求超时: ${logMessage}`);
          break;
        case 422:
          log.error(`请求格式错误: ${logMessage}`);
          break;
        case 503:
          log.error(`服务不可用: ${logMessage}`);
          break;
        case 500:
          log.error(`服务器错误: ${logMessage}`);
          break;
        default:
          log.error(`未知错误: ${logMessage}`);
          break;
      }
    } else {
      log.error('未知错误');
    }
  }

  function handleNoResponseError(error: AxiosError) {
    let logMessage = '服务器无响应:';

    if (error.config) {
      logMessage += `\n请求 URL: ${error.config.url || '未知'}`;
      logMessage += `\n请求方法: ${error.config.method || '未知'}`;

      if (error.config.headers) {
        logMessage += `\n请求头: ${JSON.stringify(error.config.headers, null, 2)}`;
      }
      if (error.config.data) {
        logMessage += `\n请求数据: ${JSON.stringify(error.config.data, null, 2)}`;
      }
    }

    if (!navigator.onLine) {
      logMessage += `\n网络连接断开，请检查您的网络连接`;
    } else {
      logMessage += `\n服务器没有响应，请检查网络连接或稍后再试`;
    }

    log.error(logMessage);
  }

  if (isAxiosError(error)) {
    if (error.response) {
      handleResponseError(error);
    } else if (error.request) {
      handleNoResponseError(error);
    }
  } else if (error instanceof Error) {
    log.error(`错误: ${error.message}`);
  } else {
    log.error('未知错误');
  }
}

function isAxiosError(error: unknown): error is import('axios').AxiosError {
  return (error as any).isAxiosError !== undefined;
}
